// mockApi.js
// 本文件为模拟接口，真实接口请参考下方注释说明

/*
1. 查询员工列表
   - HTTP方法: GET
   - 地址: /api/employees
   - 参数: 无
   - 返回值: [ { id, name, age, gender, department, status, join_date }, ... ]

2. 新增员工
   - HTTP方法: POST
   - 地址: /api/employees
   - 请求体: { name, age, gender, department, status, join_date }
   - 返回值: { id, name, age, gender, department, status, join_date }

3. 更新员工
   - HTTP方法: PUT
   - 地址: /api/employees/{id}
   - 请求体: { name, age, gender, department, status, join_date }（可部分字段）
   - 返回值: { id, name, age, gender, department, status, join_date }

4. 删除员工
   - HTTP方法: DELETE
   - 地址: /api/employees/{id}
   - 返回值: { success: true }
*/

let employees = [
  { id: 1, name: '张三', age: 28, gender: '男', department: '研发', status: true, join_date: '2022-01-10' },
  { id: 2, name: '李四', age: 32, gender: '女', department: '市场', status: false, join_date: '2021-05-20' },
  // 添加更多初始数据
  { id: 3, name: '王五', age: 25, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 4, name: '赵六', age: 29, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
  { id: 5, name: '孙七', age: 31, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 6, name: '周八', age: 27, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
  { id: 7, name: '吴九', age: 26, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 8, name: '郑十', age: 30, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
  { id: 9, name: '陈十一', age: 24, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 10, name: '刘十二', age: 28, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
  { id: 11, name: '孙十三', age: 30, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 12, name: '周十四', age: 26, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
  { id: 13, name: '吴十五', age: 27, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 14, name: '郑十六', age: 31, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
  { id: 15, name: '陈十七', age: 25, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 16, name: '刘十八', age: 29, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
  { id: 17, name: '孙十九', age: 31, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 18, name: '周二十', age: 27, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
  { id: 19, name: '吴二十一', age: 26, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 20, name: '郑二十二', age: 30, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
  { id: 21, name: '陈二十三', age: 24, gender: '男', department: '市场', status: true, join_date: '2022-01-10' },
  { id: 22, name: '刘二十四', age: 28, gender: '女', department: '研发', status: false, join_date: '2021-05-20' },
];

let nextId = 3;

// 查询所有员工
export function getEmployees() {
  // 真实接口用法：
  // return fetch('/api/employees').then(res => res.json());
  return new Promise(resolve => setTimeout(() => resolve([...employees]), 300));
}

// 新增员工
export function addEmployee(emp) {
  // 真实接口用法：
  // return fetch('/api/employees', {
  //   method: 'POST',
  //   headers: { 'Content-Type': 'application/json' },
  //   body: JSON.stringify(emp)
  // }).then(res => res.json());
  const newEmp = { ...emp, id: nextId++ };
  employees.push(newEmp);
  return new Promise(resolve => setTimeout(() => resolve(newEmp), 300));
}

// 更新员工
export function updateEmployee(id, emp) {
  // 真实接口用法：
  // return fetch(`/api/employees/${id}`, {
  //   method: 'PUT',
  //   headers: { 'Content-Type': 'application/json' },
  //   body: JSON.stringify(emp)
  // }).then(res => res.json());
  const idx = employees.findIndex(e => e.id === id);
  if (idx === -1) return Promise.resolve(null);
  employees[idx] = { ...employees[idx], ...emp };
  return new Promise(resolve => setTimeout(() => resolve(employees[idx]), 300));
}

// 删除员工
export function deleteEmployee(id) {
  // 真实接口用法：
  // return fetch(`/api/employees/${id}`, { method: 'DELETE' }).then(res => res.json());
  const idx = employees.findIndex(e => e.id === id);
  if (idx === -1) return Promise.resolve(false);
  employees.splice(idx, 1);
  return new Promise(resolve => setTimeout(() => resolve(true), 300));
}

// PATCH 更新部分字段
export async function patchEmployee(id, changes) {
  // 真实接口用法：
  // return fetch(`/api/employees/${id}`, {
  //   method: 'PATCH',
  //   headers: { 'Content-Type': 'application/json' },
  //   body: JSON.stringify(changes)
  // }).then(res => res.json());
  const idx = employees.findIndex(e => e.id === Number(id));
  if (idx === -1) return null;
  employees[idx] = { ...employees[idx], ...changes };
  return new Promise(resolve => setTimeout(() => resolve(employees[idx]), 300));
}

// 批量新增员工
export function batchAddEmployees(newArr) {
  // newArr: [{ name, age, ... }]
  // 真实接口用法：
  // return fetch('/api/employees/batch', {
  //   method: 'POST',
  //   headers: { 'Content-Type': 'application/json' },
  //   body: JSON.stringify(newArr)
  // }).then(res => res.json());
  let added = [];
  for (const emp of newArr) {
    const newEmp = { ...emp, id: nextId++ };
    employees.push(newEmp);
    added.push(newEmp);
  }
  return new Promise(resolve => setTimeout(() => resolve(added), 400));
}

// 批量全量更新员工（只处理已有员工，id!=0）
export function batchUpdateEmployees(updateArr) {
  // updateArr: [{ id, name, age, ... }]
  // 真实接口用法：
  // return fetch('/api/employees/batch', {
  //   method: 'PUT',
  //   headers: { 'Content-Type': 'application/json' },
  //   body: JSON.stringify(updateArr)
  // }).then(res => res.json());
  let updated = [];
  for (const item of updateArr) {
    if (!item.id || item.id === 0) continue;
    const idx = employees.findIndex(e => e.id === item.id);
    if (idx !== -1) {
      employees[idx] = { ...employees[idx], ...item };
      updated.push({ ...employees[idx] });
    }
  }
  return new Promise(resolve => setTimeout(() => resolve(updated), 400));
}

// 批量部分字段更新（PATCH，只处理已有员工）
export function batchPatchEmployees(patchArr) {
  // patchArr: [{ id, age, ... }]
  // 真实接口用法：
  // return fetch('/api/employees/batch', {
  //   method: 'PATCH',
  //   headers: { 'Content-Type': 'application/json' },
  //   body: JSON.stringify(patchArr)
  // }).then(res => res.json());
  let updated = [];
  for (const patch of patchArr) {
    if (!patch.id || patch.id === 0) continue;
    const idx = employees.findIndex(e => e.id === patch.id);
    if (idx !== -1) {
      employees[idx] = { ...employees[idx], ...patch };
      updated.push({ ...employees[idx] });
    }
  }
  return new Promise(resolve => setTimeout(() => resolve(updated), 400));
}

// 批量删除员工
export function batchDeleteEmployees(ids) {
  // ids: [1,2,3,...]
  // 真实接口用法：
  // return fetch('/api/employees/batch', {
  //   method: 'DELETE',
  //   headers: { 'Content-Type': 'application/json' },
  //   body: JSON.stringify(ids)
  // }).then(res => res.json());
  let count = 0;
  for (const id of ids) {
    const idx = employees.findIndex(e => e.id === id);
    if (idx !== -1) {
      employees.splice(idx, 1);
      count++;
    }
  }
  return new Promise(resolve => setTimeout(() => resolve({ success: true, deleted: count }), 400));
}

// ========== 服务端分页相关接口 ==========

// 服务端分页查询员工列表
export function getEmployeesWithPagination(params) {
  // params: { startRow, endRow, sortModel, filterModel, groupKeys, valueCols, rowGroupCols }
  // 真实接口用法：
  // return fetch('/api/employees/pagination', {
  //   method: 'POST',
  //   headers: { 'Content-Type': 'application/json' },
  //   body: JSON.stringify(params)
  // }).then(res => res.json());

  const { startRow, endRow, sortModel, filterModel } = params;

  // ========================= AG Grid filterModel 转换为 DbConditionGroup 的计算方式 =========================
  // 
  // AG Grid filterModel 结构分析：
  // 1. 单条件过滤：{ field: { filterType: 'text', type: 'contains', filter: 'value' } }
  // 2. 多条件过滤：{ field: { filterType: 'text', operator: 'AND', conditions: [condition1, condition2] } }
  // 3. 集合过滤：{ field: { filterType: 'set', values: ['value1', 'value2'] } }
  // 4. 多列过滤：{ field1: {...}, field2: {...} } (列间默认AND关系)
  //
  // 转换为 DbConditionGroup 的算法：
  // 
  // function convertFilterModelToDbConditionGroup(filterModel) {
  //   if (!filterModel || Object.keys(filterModel).length === 0) {
  //     return null;
  //   }
  //
  //   const conditions = [];
  //   
  //   // 遍历每个过滤字段
  //   Object.keys(filterModel).forEach(columnName => {
  //     const filter = filterModel[columnName];
  //     
  //     // 处理不同类型的过滤器
  //     if (filter.filterType === 'set') {
  //       // 集合过滤器：转换为 IN 条件
  //       // 示例：{ department: { filterType: 'set', values: ['人事', '市场'] } }
  //       // 转换为：{ columnName: 'department', operator: 'IN', value: ['人事', '市场'] }
  //       if (filter.values && filter.values.length > 0) {
  //         conditions.push({
  //           columnName: columnName,
  //           operator: 'IN',
  //           value: filter.values
  //         });
  //       }
  //     } else if (filter.filterType === 'text') {
  //       // 文本过滤器
  //       if (filter.conditions && filter.conditions.length > 0) {
  //         // 多条件文本过滤
  //         // 示例：{ gender: { filterType: 'text', operator: 'AND', conditions: [
  //         //   { type: 'contains', filter: 'nan' },
  //         //   { type: 'contains', filter: '1' }
  //         // ]}}
  //         
  //         if (filter.conditions.length === 1) {
  //           // 单条件直接添加
  //           const condition = filter.conditions[0];
  //           conditions.push({
  //             columnName: columnName,
  //             operator: getOperatorFromTextType(condition.type),
  //             value: condition.filter
  //           });
  //         } else {
  //           // 多条件需要创建子条件组
  //           const subConditions = filter.conditions.map(condition => ({
  //             columnName: columnName,
  //             operator: getOperatorFromTextType(condition.type),
  //             value: condition.filter
  //           }));
  //           
  //           // 创建条件组
  //           const conditionGroup = {
  //             conditions: subConditions,
  //             operator: filter.operator || 'AND'
  //           };
  //           
  //           // 将条件组添加到主条件组中
  //           // 注意：这里需要特殊处理，因为主结构需要conditionGroups数组
  //           conditions.push(conditionGroup);
  //         }
  //       } else {
  //         // 单条件文本过滤
  //         // 示例：{ gender: { filterType: 'text', type: 'contains', filter: 'nan' } }
  //         conditions.push({
  //           columnName: columnName,
  //           operator: getOperatorFromTextType(filter.type),
  //           value: filter.filter
  //         });
  //       }
  //     } else if (filter.filterType === 'number') {
  //       // 数字过滤器处理逻辑
  //       if (filter.conditions && filter.conditions.length > 0) {
  //         // 多条件数字过滤
  //         const subConditions = filter.conditions.map(condition => ({
  //           columnName: columnName,
  //           operator: getOperatorFromNumberType(condition.type),
  //           value: condition.filter
  //         }));
  //         
  //         if (subConditions.length === 1) {
  //           conditions.push(subConditions[0]);
  //         } else {
  //           conditions.push({
  //             conditions: subConditions,
  //             operator: filter.operator || 'AND'
  //           });
  //         }
  //       } else {
  //         conditions.push({
  //           columnName: columnName,
  //           operator: getOperatorFromNumberType(filter.type),
  //           value: filter.filter
  //         });
  //       }
  //     }
  //   });
  //   
  //   // 构建最终的 DbConditionGroup
  //   const result = {
  //     conditions: [],
  //     conditionGroups: [],
  //     operator: 'AND'  // 列间默认AND关系
  //   };
  //   
  //   // 分离简单条件和条件组
  //   conditions.forEach(condition => {
  //     if (condition.columnName) {
  //       // 简单条件
  //       result.conditions.push(condition);
  //     } else {
  //       // 条件组
  //       result.conditionGroups.push(condition);
  //     }
  //   });
  //   
  //   return result;
  // }
  //
  // // 辅助函数：文本类型转换为操作符
  // function getOperatorFromTextType(type) {
  //   switch (type) {
  //     case 'contains': return 'LIKE';
  //     case 'notContains': return 'NOT LIKE';
  //     case 'equals': return '=';
  //     case 'notEqual': return '<>';
  //     case 'startsWith': return 'LIKE';  // 需要在value前加%
  //     case 'endsWith': return 'LIKE';    // 需要在value后加%
  //     default: return '=';
  //   }
  // }
  //
  // // 辅助函数：数字类型转换为操作符
  // function getOperatorFromNumberType(type) {
  //   switch (type) {
  //     case 'equals': return '=';
  //     case 'notEqual': return '<>';
  //     case 'lessThan': return '<';
  //     case 'lessThanOrEqual': return '<=';
  //     case 'greaterThan': return '>';
  //     case 'greaterThanOrEqual': return '>=';
  //     case 'inRange': return 'BETWEEN';
  //     default: return '=';
  //   }
  // }
  //
  // 示例转换结果：
  // 
  // 输入 filterModel:
  // {
  //   department: { filterType: 'set', values: ['人事', '市场'] },
  //   gender: { filterType: 'text', operator: 'AND', conditions: [
  //     { type: 'contains', filter: 'nan' },
  //     { type: 'contains', filter: '1' }
  //   ]}
  // }
  //
  // 输出 DbConditionGroup:
  // {
  //   conditions: [
  //     { columnName: 'department', operator: 'IN', value: ['人事', '市场'] }
  //   ],
  //   conditionGroups: [
  //     {
  //       conditions: [
  //         { columnName: 'gender', operator: 'LIKE', value: 'nan' },
  //         { columnName: 'gender', operator: 'LIKE', value: '1' }
  //       ],
  //       operator: 'AND'
  //     }
  //   ],
  //   operator: 'AND'
  // }
  //
  // 对应的SQL逻辑：
  // (department IN ('人事', '市场')) AND (gender LIKE '%nan%' AND gender LIKE '%1%')
  //
  // ========================= 转换算法说明结束 =========================

  // 模拟数据处理逻辑
  let filteredData = [...employees];

  // 应用过滤条件（当前简化实现，实际应使用上述转换算法）
  if (filterModel) {
    Object.keys(filterModel).forEach(field => {
      const filter = filterModel[field];

      // 处理集合过滤器
      if (filter.filterType === 'set' && filter.values && filter.values.length > 0) {
        filteredData = filteredData.filter(item =>
          filter.values.includes(item[field])
        );
      }
      // 处理文本过滤器
      else if (filter.filterType === 'text') {
        if (filter.conditions && filter.conditions.length > 0) {
          // 多条件文本过滤
          filteredData = filteredData.filter(item => {
            const results = filter.conditions.map(condition => {
              if (condition.type === 'contains') {
                return String(item[field]).toLowerCase().includes(condition.filter.toLowerCase());
              }
              return true;
            });

            // 根据operator决定条件间关系
            return filter.operator === 'OR' ? results.some(r => r) : results.every(r => r);
          });
        } else if (filter.type === 'contains') {
          // 单条件文本过滤
          filteredData = filteredData.filter(item =>
            String(item[field]).toLowerCase().includes(filter.filter.toLowerCase())
          );
        }
      }
    });
  }

  // 应用排序
  if (sortModel && sortModel.length > 0) {
    filteredData.sort((a, b) => {
      for (const sort of sortModel) {
        const { colId, sort: direction } = sort;
        const aVal = a[colId];
        const bVal = b[colId];

        if (aVal < bVal) return direction === 'asc' ? -1 : 1;
        if (aVal > bVal) return direction === 'asc' ? 1 : -1;
      }
      return 0;
    });
  }

  // 分页
  const totalRows = filteredData.length;
  const paginatedData = filteredData.slice(startRow, endRow);

  return new Promise(resolve => setTimeout(() => resolve({
    rows: paginatedData,
    lastRow: totalRows
  }), 300));
}

// 获取员工总数（用于分页）
export function getEmployeesCount() {
  return new Promise(resolve => setTimeout(() => resolve(employees.length), 100));
}

// ========== 统一批量操作接口 ==========

/**
 * 统一批量操作接口 - 同时处理新增、修改、删除操作
 * 保证数据一致性的最佳实践
 * 
 * @param {Object} changes - 包含所有待处理的操作
 * @param {Array} changes.add - 新增的员工数组
 * @param {Array} changes.update - 修改的员工数组（包含id和修改的字段）
 * @param {Array} changes.remove - 要删除的员工ID数组
 * @returns {Promise<Object>} 返回处理结果
 */
export function batchProcessChanges(changes) {
  // 真实接口用法：
  // return fetch('/api/employees/batch-process', {
  //   method: 'POST',
  //   headers: { 'Content-Type': 'application/json' },
  //   body: JSON.stringify(changes)
  // }).then(res => res.json());

  const { add = [], update = [], remove = [] } = changes;
  const result = {
    success: true,
    add: { count: 0, data: [] },
    update: { count: 0, data: [] },
    remove: { count: 0, data: [] },
    errors: []
  };

  try {
    // 1. 先处理删除操作（避免删除后修改的问题）
    for (const id of remove) {
      const idx = employees.findIndex(e => e.id === id);
      if (idx !== -1) {
        const deletedEmp = employees.splice(idx, 1)[0];
        result.remove.data.push(deletedEmp);
        result.remove.count++;
      } else {
        result.errors.push(`删除失败：员工ID ${id} 不存在`);
      }
    }

    // 2. 处理修改操作
    for (const emp of update) {
      const idx = employees.findIndex(e => e.id === emp.id);
      if (idx !== -1) {
        employees[idx] = { ...employees[idx], ...emp };
        result.update.data.push({ ...employees[idx] });
        result.update.count++;
      } else {
        result.errors.push(`修改失败：员工ID ${emp.id} 不存在`);
      }
    }

    // 3. 处理新增操作
    for (const emp of add) {
      const newEmp = { ...emp, id: nextId++ };
      employees.push(newEmp);
      result.add.data.push(newEmp);
      result.add.count++;
    }

    // 如果有错误，标记为失败
    if (result.errors.length > 0) {
      result.success = false;
    }

    return new Promise(resolve => setTimeout(() => resolve(result), 500));
  } catch (error) {
    return new Promise((resolve, reject) => setTimeout(() => reject({
      success: false,
      error: error.message,
      errors: [`批量操作失败：${error.message}`]
    }), 100));
  }
}

// ========== 真实API分页查询接口 ==========

/**
 * 从真实API获取分页数据
 * @param {Object} params - AG Grid分页参数
 * @returns {Promise<Object>} 返回分页数据
 */
export async function getEmployeesWithPaginationByApi(params) {
  const { startRow, endRow, sortModel, filterModel } = params;

  try {
    // 构建请求参数
    const requestParams = {
      // 固定参数
      applicationId: 32,
      tableName: 'employee',

      // 列参数
      tableColumn: [
        {
          columnName: "id",
          format: "",
          isShow: true
        },
        {
          columnName: "name",
          format: "",
          isShow: true
        },
        {
          columnName: "age",
          format: "",
          isShow: true
        },
        {
          columnName: "gender",
          format: "",
          isShow: true
        },
        {
          columnName: "department",
          format: "",
          isShow: true
        },
        {
          columnName: "join_date",
          format: "YYYY-MM-DD",
          isShow: true
        },
        {
          columnName: "status",
          format: "",
          isShow: true
        }
      ],

      // 分页参数
      page: Math.floor(startRow / (endRow - startRow)) + 1, // 页码（从1开始）
      size: endRow - startRow, // 每页大小

      // 排序参数 - 转换为sorts数组格式
      sorts: sortModel && sortModel.length > 0 ? sortModel.map(sort => ({
        sortBy: sort.colId,  // 排序字段
        sort: sort.sort      // 排序方式：asc/desc
      })) : [],

      // 过滤条件 - 转换为DbConditionGroup格式，注意这里应该是conditionGroup而不是conditions
      conditionGroup: convertFilterModelToDbConditionGroup(filterModel)
    };

    console.log("requestParams", requestParams);

    // 发送请求到真实API
    const response = await fetch('http://localhost:8888/esuncode/api/v1/datasource/getResultPageByAppIdNew', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3NTI3NTk2MjIsInVzZXJJZCI6MiwidXNlcm5hbWUiOiJ5dXp1ZGVuZyJ9.TrRqWn3KnYxnyfxE5yjxCnT1dhIA_ldx8RPEq-vhM0o'
      },
      body: JSON.stringify(requestParams)
    });

    // 检查响应状态
    if (!response.ok) {
      throw new Error(`API请求失败: ${response.status} ${response.statusText}`);
    }

    // 解析响应数据
    const responseData = await response.json();

    // 根据实际API响应格式调整数据结构
    // API返回格式为:
    /*
      {
        "code": 200,
        "data": [  // 数据列表
          {}
        ],
        "message": "",
        "numberOfElements": 0,  // 当前页数据条数
        "offset": 0,  // 偏移量
        "pageNumber": 0,  // 当前页码
        "pageSize": 0,  // 每页大小
        "totalElements": 0,  // 总数据条数
        "totalPages": 0  // 总页数
      }
    */
    if (responseData.code === 200) {
      const records = responseData.data;

      // 转换为AG Grid期望的格式
      return {
        rows: records,
        lastRow: responseData.totalElements
      };
    } else {
      throw new Error(`API返回错误: ${responseData.message || '未知错误'}`);
    }

  } catch (error) {
    console.error('API请求失败:', error);

    // 错误处理 - 返回空结果或抛出错误
    throw new Error(`获取员工数据失败: ${error.message}`);

    // 或者返回空结果（取决于你的错误处理策略）
    // return {
    //   rows: [],
    //   lastRow: 0
    // };
  }
}

// ========== 统一批量操作接口 ==========

/**
 * 统一批量操作接口 - 同时处理新增、修改、删除操作
 * 保证数据一致性的最佳实践
 *
 * @param {Object} changes - 包含所有待处理的操作
 * @param {Array} changes.add - 新增的员工数组
 * @param {Array} changes.update - 修改的员工数组（包含keys和changes）
 * @param {Array} changes.remove - 要删除的员工数组（包含主键信息）
 * @returns {Promise<Object>} 返回处理结果
 */
export async function batchProcessChangesByApi(changes, primaryKeyConfig) {
  const { add = [], update = [], remove = [] } = changes;

  try {
    // 构建 API 请求参数
    const requestParams = {
      // 固定参数
      applicationId: 32,
      tableName: 'employee',

      // 新增操作参数转换
      addValue: convertAddToApiFormat(add, primaryKeyConfig.fields),

      // 删除操作参数转换
      removeValue: convertRemoveToApiFormat(remove),

      // 更新操作参数转换
      updateValue: convertUpdateToApiFormat(update)
    };

    console.log("批量操作请求参数:", JSON.stringify(requestParams, null, 2));
    // return;
    // 发送请求到真实API
    const response = await fetch('http://localhost:8888/esuncode/api/v1/datasource/executeBatchProcessChangesByAppId', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3NTI3NTk2MjIsInVzZXJJZCI6MiwidXNlcm5hbWUiOiJ5dXp1ZGVuZyJ9.TrRqWn3KnYxnyfxE5yjxCnT1dhIA_ldx8RPEq-vhM0o'
      },
      body: JSON.stringify(requestParams)
    });

    // 检查响应状态
    if (!response.ok) {
      throw new Error(`API请求失败: ${response.status} ${response.statusText}`);
    }

    // 解析响应数据
    const responseData = await response.json();

    console.log("批量操作响应数据:", responseData);

    // 根据实际API响应格式调整返回数据结构
    if (responseData.code === 200) {
      return {
        success: true,
        data: responseData.data,
        message: responseData.message || '批量操作成功'
      };
    } else {
      throw new Error(`API返回错误: ${responseData.message || '未知错误'}`);
    }

  } catch (error) {
    console.error('批量操作API请求失败:', error);
    throw new Error(`批量操作失败: ${error.message}`);
  }
}

/**
 * 将新增数据转换为API所需格式
 * @param {Array} addData - 新增数据数组
 * @returns {Array} API格式的新增数据
 */
function convertAddToApiFormat(addData) {
  /* 输入结构
  [
    {
      "user_id": 12345,
      "username": "john_doe",
      "signup_date": "2023-05-15",
      "premium_member": true,
      "monthly_spend": 49.99
    },
    {
      "product_id": "550e8400-e29b-41d4-a716-446655440000",
      "product_name": "Wireless Headphones",
      "price": 129.99,
      "in_stock": false,
      "specs": {"color": "black", "battery_life": "30 hours", "weight": "250g"}
    }
  ]
   */
  /* 目标结构
  [
    {
      "insertValue": [
        {"columnName": "user_id", "format": "integer", "value": 12345},
        {"columnName": "username", "format": "string", "value": "john_doe"},
        ...
      ]
    },
    ...
  ]
  */

  if (!addData || addData.length === 0) {
    return [];
  }


  // 转换每条新增数据
  return addData.map(record => {
    const columnValues = [];
    Object.keys(record).forEach(columnName => {
      if (!primaryKeyConfig.fields.includes(columnName)) {
        const value = record[columnName];
        const format = getColumnFormat(columnName);
        columnValues.push({
          columnName,
          format,
          value
        });
      }
    });
    return {
      insertValue: columnValues
    };
  });
}

// ================== 测试用例 ==================
function testConvertAddToApiFormat() {
  // 用例1：用户信息
  const input1 = [
    {
      user_id: 12345,
      username: "john_doe",
      signup_date: "2023-05-15",
      premium_member: true,
      monthly_spend: 49.99
    }
  ];
  console.log('测试用例1结果:', JSON.stringify(convertAddToApiFormat(input1), null, 2));

  // 用例2：产品信息
  const input2 = [
    {
      product_id: "550e8400-e29b-41d4-a716-446655440000",
      product_name: "Wireless Headphones",
      price: 129.99,
      in_stock: false,
      specs: {
        color: "black",
        battery_life: "30 hours",
        weight: "250g"
      }
    }
  ];
  console.log('测试用例2结果:', JSON.stringify(convertAddToApiFormat(input2), null, 2));

  // 用例3：混合类型
  const input3 = [
    {
      id: 1,
      name: "张三",
      age: 28,
      gender: "男",
      department: "研发",
      status: true,
      join_date: "2022-01-10"
    }
  ];
  console.log('测试用例3结果:', JSON.stringify(convertAddToApiFormat(input3), null, 2));
}
// 取消注释下一行可直接运行测试
// testConvertAddToApiFormat();

/**
 * 将删除数据转换为API所需格式
 * @param {Array} removeData - 删除数据数组
 * @returns {Object} API格式的删除条件
 */
function convertRemoveToApiFormat(removeData) {
  if (!removeData || removeData.length === 0) {
    return {
      conditions: [],
      conditionGroups: [],
      operator: 'AND'
    };
  }

  const conditions = [];

  // 将每个删除记录转换为条件
  removeData.forEach(record => {
    // 构建主键条件组（id + name 联合主键）
    const recordConditions = [];

    Object.keys(record).forEach(columnName => {
      const value = record[columnName];
      recordConditions.push({
        columnName: columnName,
        dataType: getDataType(columnName),
        format: getColumnFormat(columnName),
        operator: '=',
        value: value
      });
    });

    // 如果是单个主键，直接添加条件
    if (recordConditions.length === 1) {
      conditions.push(recordConditions[0]);
    } else {
      // 多个主键字段，创建条件组（AND关系）
      conditions.push({
        conditions: recordConditions,
        conditionGroups: [],
        operator: 'AND'
      });
    }
  });

  // 多个删除记录之间是OR关系
  if (conditions.length === 1 && conditions[0].columnName) {
    // 单个简单条件
    return {
      conditions: conditions,
      conditionGroups: [],
      operator: 'AND'
    };
  } else {
    // 多个条件或条件组，使用OR关系
    return {
      conditions: [],
      conditionGroups: conditions.map(condition =>
        condition.columnName ? {
          conditions: [condition],
          conditionGroups: [],
          operator: 'AND'
        } : condition
      ),
      operator: 'OR'
    };
  }
}

/**
 * 将更新数据转换为API所需格式
 * @param {Array} updateData - 更新数据数组
 * @returns {Array} API格式的更新数据
 */
function convertUpdateToApiFormat(updateData) {
  if (!updateData || updateData.length === 0) {
    return [];
  }

  return updateData.map(updateRecord => {
    const { keys, changes } = updateRecord;

    // 构建查询条件（基于主键）
    const keyConditions = [];
    Object.keys(keys).forEach(columnName => {
      const value = keys[columnName];
      keyConditions.push({
        columnName: columnName,
        dataType: getDataType(columnName),
        format: getColumnFormat(columnName),
        operator: '=',
        value: value
      });
    });

    // 构建更新字段
    const updateColumns = [];
    Object.keys(changes).forEach(columnName => {
      const value = changes[columnName];
      updateColumns.push({
        columnName: columnName,
        format: getColumnFormat(columnName),
        value: value
      });
    });

    return {
      conditionGroup: {
        conditions: keyConditions,
        conditionGroups: [],
        operator: 'AND'
      },
      updateValue: updateColumns
    };
  });
}

/**
 * 根据字段名获取数据类型
 * @param {string} columnName - 字段名
 * @returns {string} 数据类型
 */
function getDataType(columnName) {
  const dataTypeMap = {
    'id': 'int',
    'name': 'varchar',
    'age': 'int',
    'gender': 'varchar',
    'department': 'varchar',
    'status': 'boolean',
    'join_date': 'date'
  };

  return dataTypeMap[columnName] || 'varchar';
}

/**
 * 根据字段名获取格式
 * @param {string} columnName - 字段名
 * @returns {string} 格式字符串
 */
function getColumnFormat(columnName) {
  const formatMap = {
    'join_date': 'YYYY-MM-DD'
  };

  return formatMap[columnName] || '';
}
/**
 * 将AG Grid的filterModel转换为DbConditionGroup格式（实际使用版本）
 * 
 * AG Grid filterModel 结构分析：
 * 1. 单条件过滤：{ field: { filterType: 'text', type: 'contains', filter: 'value' } }
 * 2. 多条件过滤：{ field: { filterType: 'text', operator: 'AND', conditions: [condition1, condition2] } }
 * 3. 集合过滤：{ field: { filterType: 'set', values: ['value1', 'value2'] } }
 * 4. 多列过滤：{ field1: {...}, field2: {...} } (列间默认AND关系)
 * 
 * @param {Object} filterModel - AG Grid的过滤模型
 * @returns {Object|null} DbConditionGroup格式的过滤条件
 * 
 * @example
 * // 输入 filterModel:
 * {
 *   department: { filterType: 'set', values: ['人事', '市场'] },
 *   gender: { 
 *     filterType: 'text', 
 *     operator: 'AND', 
 *     conditions: [
 *       { type: 'contains', filter: 'nan' },
 *       { type: 'contains', filter: '1' }
 *     ]
 *   }
 * }
 * 
 * // 输出 DbConditionGroup:
 * {
 *   conditions: [
 *     { columnName: 'department', operator: 'IN', value: ['人事', '市场'] }
 *   ],
 *   conditionGroups: [
 *     {
 *       conditions: [
 *         { columnName: 'gender', operator: 'LIKE', value: '%nan%' },
 *         { columnName: 'gender', operator: 'LIKE', value: '%1%' }
 *       ],
 *       operator: 'AND'
 *     }
 *   ],
 *   operator: 'AND'
 * }
 */
function convertFilterModelToDbConditionGroup(filterModel) {
  if (!filterModel || Object.keys(filterModel).length === 0) {
    return null;
  }

  const conditions = [];
  const conditionGroups = [];

  // 遍历每个过滤字段
  Object.keys(filterModel).forEach(columnName => {
    const filter = filterModel[columnName];

    // 处理不同类型的过滤器
    if (filter.filterType === 'set') {
      // 集合过滤器：转换为 IN 条件
      // 示例：{ department: { filterType: 'set', values: ['人事', '市场'] } }
      // 转换为：{ columnName: 'department', operator: 'IN', value: ['人事', '市场'] }
      if (filter.values && filter.values.length > 0) {
        conditions.push({
          columnName: columnName,
          operator: 'IN',
          value: filter.values
        });
      }
    } else if (filter.filterType === 'text') {
      // 文本过滤器
      if (filter.conditions && filter.conditions.length > 0) {
        // 多条件文本过滤
        // 示例：{ gender: { filterType: 'text', operator: 'AND', conditions: [
        //   { type: 'contains', filter: 'nan' },
        //   { type: 'contains', filter: '1' }
        // ]}}
        if (filter.conditions.length === 1) {
          // 单条件直接添加到主条件列表
          const condition = filter.conditions[0];
          conditions.push({
            columnName: columnName,
            operator: getOperatorFromTextType(condition.type),
            value: getValueFromTextCondition(condition)
          });
        } else {
          // 多条件需要创建子条件组
          const subConditions = filter.conditions.map(condition => ({
            columnName: columnName,
            operator: getOperatorFromTextType(condition.type),
            value: getValueFromTextCondition(condition)
          }));

          // 创建条件组
          conditionGroups.push({
            conditions: subConditions,
            operator: filter.operator || 'AND'
          });
        }
      } else {
        // 单条件文本过滤
        // 示例：{ gender: { filterType: 'text', type: 'contains', filter: 'nan' } }
        conditions.push({
          columnName: columnName,
          operator: getOperatorFromTextType(filter.type),
          value: getValueFromTextCondition(filter)
        });
      }
    } else if (filter.filterType === 'number') {
      // 数字过滤器处理逻辑
      if (filter.conditions && filter.conditions.length > 0) {
        // 多条件数字过滤
        if (filter.conditions.length === 1) {
          const condition = filter.conditions[0];
          conditions.push({
            columnName: columnName,
            operator: getOperatorFromNumberType(condition.type),
            value: getValueFromNumberCondition(condition)
          });
        } else {
          const subConditions = filter.conditions.map(condition => ({
            columnName: columnName,
            operator: getOperatorFromNumberType(condition.type),
            value: getValueFromNumberCondition(condition)
          }));

          conditionGroups.push({
            conditions: subConditions,
            operator: filter.operator || 'AND'
          });
        }
      } else {
        // 单条件数字过滤
        conditions.push({
          columnName: columnName,
          operator: getOperatorFromNumberType(filter.type),
          value: getValueFromNumberCondition(filter)
        });
      }
    } else if (filter.filterType === 'date') {
      // 日期过滤器处理逻辑
      if (filter.conditions && filter.conditions.length > 0) {
        if (filter.conditions.length === 1) {
          const condition = filter.conditions[0];
          conditions.push({
            columnName: columnName,
            operator: getOperatorFromDateType(condition.type),
            value: condition.dateFrom || condition.dateTo
          });
        } else {
          const subConditions = filter.conditions.map(condition => ({
            columnName: columnName,
            operator: getOperatorFromDateType(condition.type),
            value: condition.dateFrom || condition.dateTo
          }));

          conditionGroups.push({
            conditions: subConditions,
            operator: filter.operator || 'AND'
          });
        }
      } else {
        conditions.push({
          columnName: columnName,
          operator: getOperatorFromDateType(filter.type),
          value: filter.dateFrom || filter.dateTo
        });
      }
    }
  });

  // 构建最终的 DbConditionGroup
  const result = {
    operator: 'AND'  // 列间默认AND关系
  };

  // 只有在有条件时才添加对应的字段
  if (conditions.length > 0) {
    result.conditions = conditions;
  }

  if (conditionGroups.length > 0) {
    result.conditionGroups = conditionGroups;
  }

  return result;
}

/**
 * 文本类型转换为操作符
 * 将AG Grid的文本过滤类型转换为数据库操作符
 * 
 * @param {string} type - AG Grid文本过滤类型
 * @returns {string} 数据库操作符
 * 
 * @example
 * getOperatorFromTextType('contains') // 返回 'LIKE'
 * getOperatorFromTextType('equals') // 返回 '='
 * getOperatorFromTextType('startsWith') // 返回 'LIKE' (需要配合值处理)
 */
function getOperatorFromTextType(type) {
  switch (type) {
    case 'contains': return 'LIKE';        // 包含 -> LIKE '%value%'
    case 'notContains': return 'NOT LIKE'; // 不包含 -> NOT LIKE '%value%'
    case 'equals': return '=';             // 等于 -> = 'value'
    case 'notEqual': return '<>';          // 不等于 -> <> 'value'
    case 'startsWith': return 'LIKE';      // 开头匹配 -> LIKE 'value%'
    case 'endsWith': return 'LIKE';        // 结尾匹配 -> LIKE '%value'
    case 'blank': return 'IS NULL';        // 空值 -> IS NULL
    case 'notBlank': return 'IS NOT NULL'; // 非空值 -> IS NOT NULL
    default: return '=';                   // 默认等于
  }
}

/**
 * 数字类型转换为操作符
 * 将AG Grid的数字过滤类型转换为数据库操作符
 * 
 * @param {string} type - AG Grid数字过滤类型
 * @returns {string} 数据库操作符
 * 
 * @example
 * getOperatorFromNumberType('greaterThan') // 返回 '>'
 * getOperatorFromNumberType('inRange') // 返回 'BETWEEN'
 * getOperatorFromNumberType('equals') // 返回 '='
 */
function getOperatorFromNumberType(type) {
  switch (type) {
    case 'equals': return '=';               // 等于 -> = value
    case 'notEqual': return '<>';            // 不等于 -> <> value
    case 'lessThan': return '<';             // 小于 -> < value
    case 'lessThanOrEqual': return '<=';     // 小于等于 -> <= value
    case 'greaterThan': return '>';          // 大于 -> > value
    case 'greaterThanOrEqual': return '>=';  // 大于等于 -> >= value
    case 'inRange': return 'BETWEEN';        // 范围内 -> BETWEEN value1 AND value2
    case 'blank': return 'IS NULL';          // 空值 -> IS NULL
    case 'notBlank': return 'IS NOT NULL';   // 非空值 -> IS NOT NULL
    default: return '=';                     // 默认等于
  }
}

/**
 * 日期类型转换为操作符
 * 将AG Grid的日期过滤类型转换为数据库操作符
 * 
 * @param {string} type - AG Grid日期过滤类型
 * @returns {string} 数据库操作符
 * 
 * @example
 * getOperatorFromDateType('greaterThan') // 返回 '>'
 * getOperatorFromDateType('inRange') // 返回 'BETWEEN'
 * getOperatorFromDateType('equals') // 返回 '='
 */
function getOperatorFromDateType(type) {
  switch (type) {
    case 'equals': return '=';             // 等于 -> = '2023-01-01'
    case 'notEqual': return '<>';          // 不等于 -> <> '2023-01-01'
    case 'lessThan': return '<';           // 早于 -> < '2023-01-01'
    case 'greaterThan': return '>';        // 晚于 -> > '2023-01-01'
    case 'inRange': return 'BETWEEN';      // 范围内 -> BETWEEN '2023-01-01' AND '2023-12-31'
    case 'blank': return 'IS NULL';        // 空值 -> IS NULL
    case 'notBlank': return 'IS NOT NULL'; // 非空值 -> IS NOT NULL
    default: return '=';                   // 默认等于
  }
}

/**
 * 从文本条件中获取值，处理LIKE操作符的通配符
 * 根据不同的文本过滤类型，为值添加适当的通配符
 * 
 * @param {Object} condition - 文本条件对象
 * @param {string} condition.type - 过滤类型
 * @param {string} condition.filter - 过滤值
 * @returns {string|null} 处理后的值
 * 
 * @example
 * getValueFromTextCondition({ type: 'contains', filter: 'test' }) // 返回 '%test%'
 * getValueFromTextCondition({ type: 'startsWith', filter: 'test' }) // 返回 'test%'
 * getValueFromTextCondition({ type: 'equals', filter: 'test' }) // 返回 'test'
 */
function getValueFromTextCondition(condition) {
  const value = condition.filter;

  switch (condition.type) {
    case 'contains':
    case 'notContains':
      return `%${value}%`;  // 包含/不包含 -> %value%
    case 'startsWith':
      return `${value}%`;   // 开头匹配 -> value%
    case 'endsWith':
      return `%${value}`;   // 结尾匹配 -> %value
    case 'blank':
    case 'notBlank':
      return null;          // 空值/非空值 -> null (使用IS NULL/IS NOT NULL)
    default:
      return value;         // 其他情况直接返回原值
  }
}

/**
 * 从数字条件中获取值，处理BETWEEN操作符的范围值
 * 根据不同的数字过滤类型，返回适当格式的值
 * 
 * @param {Object} condition - 数字条件对象
 * @param {string} condition.type - 过滤类型
 * @param {number} condition.filter - 过滤值
 * @param {number} [condition.filterTo] - 范围过滤的结束值
 * @returns {number|Array|null} 处理后的值
 * 
 * @example
 * getValueFromNumberCondition({ type: 'equals', filter: 10 }) // 返回 10
 * getValueFromNumberCondition({ type: 'inRange', filter: 10, filterTo: 20 }) // 返回 [10, 20]
 * getValueFromNumberCondition({ type: 'blank' }) // 返回 null
 */
function getValueFromNumberCondition(condition) {
  switch (condition.type) {
    case 'inRange':
      return [condition.filter, condition.filterTo];  // 范围 -> [min, max]
    case 'blank':
    case 'notBlank':
      return null;                                    // 空值/非空值 -> null
    default:
      return condition.filter;                        // 其他情况返回过滤值
  }
}

// ========================= AG Grid filterModel 转换为 DbConditionGroup 详细说明 =========================

/**
 * AG Grid filterModel 转换为 DbConditionGroup 的完整转换逻辑说明
 *
 * 本模块提供了将AG Grid的过滤模型转换为后端API所需的DbConditionGroup格式的完整解决方案。
 *
 * 转换支持的过滤类型：
 * 1. 文本过滤 (filterType: 'text')
 *    - 单条件：contains, equals, startsWith, endsWith, blank, notBlank
 *    - 多条件：支持AND/OR组合
 *
 * 2. 数字过滤 (filterType: 'number')
 *    - 单条件：equals, greaterThan, lessThan, inRange等
 *    - 多条件：支持AND/OR组合
 *
 * 3. 日期过滤 (filterType: 'date')
 *    - 单条件：equals, greaterThan, lessThan, inRange等
 *    - 多条件：支持AND/OR组合
 *
 * 4. 集合过滤 (filterType: 'set')
 *    - 转换为IN操作符
 *
 * 转换原理：
 * - 单条件直接转换为conditions数组中的条件
 * - 多条件创建conditionGroups数组中的条件组
 * - 列间关系默认为AND
 * - 支持嵌套的复杂条件组合
 *
 * 主要函数：
 * - convertFilterModelToDbConditionGroup(): 主转换函数
 * - getOperatorFromTextType(): 文本操作符转换
 * - getOperatorFromNumberType(): 数字操作符转换
 * - getOperatorFromDateType(): 日期操作符转换
 * - getValueFromTextCondition(): 文本值处理（通配符）
 * - getValueFromNumberCondition(): 数字值处理（范围）
 */

// 使用示例和测试用例

/*
function testConversion() {
  // 测试用例1：复合过滤条件
  const filterModel1 = {
    department: { filterType: 'set', values: ['人事', '市场'] },
    gender: {
      filterType: 'text',
      operator: 'OR',
      conditions: [
        { type: 'contains', filter: 'nan' },
        { type: 'contains', filter: '1' }
      ]
    }
  };

  const result1 = convertFilterModelToDbConditionGroup(filterModel1);
  console.log('测试用例1结果:', JSON.stringify(result1, null, 2));

  // 预期结果：
  // {
  //   "conditions": [
  //     { "columnName": "department", "operator": "IN", "value": ["人事", "市场"] }
  //   ],
  //   "conditionGroups": [
  //     {
  //       "conditions": [
  //         { "columnName": "gender", "operator": "LIKE", "value": "%nan%" },
  //         { "columnName": "gender", "operator": "LIKE", "value": "%1%" }
  //       ],
  //       "operator": "AND"
  //     }
  //   ],
  //   "operator": "AND"
  // }

  // 测试用例2：简单过滤条件
  const filterModel2 = {
    department: { filterType: 'set', values: ['人事', '市场'] },
    gender: { filterType: 'text', type: 'contains', filter: 'nan' }
  };

  const result2 = convertFilterModelToDbConditionGroup(filterModel2);
  console.log('测试用例2结果:', JSON.stringify(result2, null, 2));

  // 预期结果：
  // {
  //   "conditions": [
  //     { "columnName": "department", "operator": "IN", "value": ["人事", "市场"] },
  //     { "columnName": "gender", "operator": "LIKE", "value": "%nan%" }
  //   ],
  //   "operator": "AND"
  // }
}

// 取消注释下面这行来运行测试
// testConversion();
*/

// ========================= 使用示例 =========================
/*
// 在 EmployeeGrid.js 中使用真实API的示例：

// 1. 导入新的API方法
import { getEmployeesWithPaginationByApi } from './mockApi.js';

// 2. 修改数据源配置
const datasource = {
  getRows: async (params) => {
    try {
      console.log('数据源请求参数:', params.request);

      // 使用真实API获取数据
      const result = await getEmployeesWithPaginationByApi(params.request);

      console.log('API返回数据:', result);

      // 成功回调
      params.success({
        rowData: result.rows,
        rowCount: result.lastRow
      });

    } catch (error) {
      console.error('数据加载失败:', error);

      // 失败回调
      params.fail();

      // 可选：显示错误提示
      // alert('数据加载失败: ' + error.message);
    }
  }
};

// 3. 在网格初始化时设置数据源
useEffect(() => {
  if (gridRef.current && gridRef.current.api) {
    gridRef.current.api.setGridOption('serverSideDatasource', datasource);
  }
}, []);

// 注意事项：
// 1. 确保API接口返回的数据格式与AG Grid期望的格式匹配
// 2. 根据实际API响应格式调整 getEmployeesWithPaginationByApi 中的数据处理逻辑
// 3. 处理API请求失败的情况，提供用户友好的错误提示
// 4. 可以添加加载状态指示器来提升用户体验
*/

// ========================= API接口参数说明 =========================
/*
// 发送到后端API的请求参数格式：
{
  "applicationId": 32,           // 固定值
  "tableName": "employee",       // 固定值
  "page": 1,                     // 页码（从1开始）
  "size": 10,                    // 每页大小
  "sorts": [                     // 排序信息数组（可选）
    {
      "sortBy": "name",          // 排序字段
      "sort": "asc"              // 排序方向：asc/desc
    }
  ],
  "conditionGroup": {            // 过滤条件（可选）
    "conditions": [
      {
        "columnName": "department",
        "operator": "IN",
        "value": ["人事", "市场"],
        "dataType": "varchar",   // 字段数据类型（可选）
        "format": ""             // 字段格式（可选）
      }
    ],
    "conditionGroups": [
      {
        "conditions": [
          {
            "columnName": "gender",
            "operator": "LIKE",
            "value": "%nan%"
          }
        ],
        "operator": "AND"
      }
    ],
    "operator": "AND"
  },
  "tableColumn": [               // 数据表字段格式（可选）
    {
      "columnName": "name",
      "format": "",
      "isShow": true
    }
  ],
  "search": ""                   // 搜索关键字（可选）
}

// 期望的API响应格式：
{
  "code": 200,                   // 状态码
  "data": [                      // 数据列表
    {
      "id": 1,
      "name": "张三",
      "age": 28,
      "gender": "男",
      "department": "研发",
      "status": true,
      "join_date": "2022-01-10"
    }
    // ... 更多记录
  ],
  "message": "",                 // 响应消息
  "numberOfElements": 10,        // 当前页数据条数
  "offset": 0,                   // 偏移量
  "pageNumber": 1,               // 当前页码
  "pageSize": 10,                // 每页大小
  "totalElements": 100,          // 总数据条数
  "totalPages": 10               // 总页数
}

// 如果API响应格式不同，请相应调整 getEmployeesWithPaginationByApi 函数中的数据处理逻辑
*/ 